package io.rong;

import java.io.Reader;
import java.util.List;
import java.util.Map;

import io.rong.models.*;
import org.junit.Test;

/**
 * 融云通讯api的调用
 */
public class RongCloudUtil {
    private static String rcApiUrl = "http://api.cn.ronghub.com";
    ;
    private String appKey;
    private String appSecret;
    private static RongCloudUtil rcu = null;
    private static RongCloud rongCloud = null;
    private static final String JSONFILE = RongCloudUtil.class.getClassLoader().getResource("jsonsource").getPath()
            + "/";

    public static synchronized RongCloudUtil getInstance(String appKey, String appSecret) {
        if (null != rcu) {
            return rcu;
        } else {
            rongCloud = RongCloud.getInstance(appKey, appSecret, rcApiUrl);
            return new RongCloudUtil(appKey, appSecret);
        }
    }

    public RongCloudUtil() {
    }

    ;

    public RongCloudUtil(String appKey, String appSecret) {
        this.appKey = appKey;
        this.appSecret = appSecret;

    }

    /**
     * 本地调用测试
     *
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        String appKey = "appkey";// 替换成您的appkey
        appKey = "82hegw5u8dtix";// 替换成您的appkey
        String appSecret = "secret";// 替换成匹配上面key的secret
        appSecret = "bTFrOJv09Ykx";// 替换成匹配上面key的secret
        Reader reader = null;
        RongCloud rongCloud = RongCloud.getInstance(appKey, appSecret, "http://api.cn.ronghub.com");

        System.out.println("************************User********************");

        /**
         *
         *
         * // 封禁用户方法（每秒钟限 100 次） CodeSuccessResult userBlockResult =
         * rongCloud.user.block("userId4", 10); System.out.println("block:  " +
         * userBlockResult.toString());
         *
         * // 解除用户封禁方法（每秒钟限 100 次） CodeSuccessResult userUnBlockResult =
         * rongCloud.user.unBlock("userId2"); System.out.println("unBlock:  " +
         * userUnBlockResult.toString());
         *
         * // 获取被封禁用户方法（每秒钟限 100 次） QueryBlockUserResult userQueryBlockResult =
         * rongCloud.user.queryBlock(); System.out.println("queryBlock:  " +
         * userQueryBlockResult.toString());

         *
         *
         *
         * System.out.println("************************Message********************"); //
         * 发送单聊消息方法（一个用户向另外一个用户发送消息，单条消息最大 128k。每分钟最多发送 6000 条信息，每次发送用户上限为 1000 人，如：一次发送
         * 1000 人时，示为 1000 条消息。） String[] messagePublishPrivateToUserId =
         * {"userId2","userid3","userId4"}; VoiceMessage
         * messagePublishPrivateVoiceMessage = new VoiceMessage("hello", "helloExtra",
         * 20L); CodeSuccessResult messagePublishPrivateResult =
         * rongCloud.message.publishPrivate("userId1", messagePublishPrivateToUserId,
         * messagePublishPrivateVoiceMessage, "thisisapush", "{\"pushData\":\"hello\"}",
         * "4", 0, 0, 0, 0); System.out.println("publishPrivate:  " +
         * messagePublishPrivateResult.toString());
         *
         * // 发送单聊模板消息方法（一个用户向多个用户发送不同消息内容，单条消息最大 128k。每分钟最多发送 6000 条信息，每次发送用户上限为 1000
         * 人。） try { reader = new InputStreamReader(new
         * FileInputStream(JSONFILE+"TemplateMessage.json")); TemplateMessage
         * publishTemplateTemplateMessage = (TemplateMessage)GsonUtil.fromJson(reader,
         * TemplateMessage.class); CodeSuccessResult messagePublishTemplateResult =
         * rongCloud.message.publishTemplate(publishTemplateTemplateMessage);
         * System.out.println("publishTemplate:  " +
         * messagePublishTemplateResult.toString()); } catch (Exception e) { // TODO:
         * handle exception e.printStackTrace(); }finally { if(null != reader){
         * reader.close(); } }
         *
         * // 发送系统消息方法（一个用户向一个或多个用户发送系统消息，单条消息最大 128k，会话类型为 SYSTEM。每秒钟最多发送 100
         * 条消息，每次最多同时向 100 人发送，如：一次发送 100 人时，示为 100 条消息。） String[]
         * messagePublishSystemToUserId = {"userId2","userid3","userId4"}; TxtMessage
         * messagePublishSystemTxtMessage = new TxtMessage("hello", "helloExtra");
         * CodeSuccessResult messagePublishSystemResult =
         * rongCloud.message.PublishSystem("userId1", messagePublishSystemToUserId,
         * messagePublishSystemTxtMessage, "thisisapush", "{\"pushData\":\"hello\"}", 0,
         * 0); System.out.println("PublishSystem:  " +
         * messagePublishSystemResult.toString());
         *
         * // 发送系统模板消息方法（一个用户向一个或多个用户发送系统消息，单条消息最大 128k，会话类型为 SYSTEM.每秒钟最多发送 100
         * 条消息，每次最多同时向 100 人发送，如：一次发送 100 人时，示为 100 条消息。） try { reader = new
         * InputStreamReader(new FileInputStream(JSONFILE+"TemplateMessage.json"));
         * TemplateMessage publishSystemTemplateTemplateMessage =
         * (TemplateMessage)GsonUtil.fromJson(reader, TemplateMessage.class);
         * CodeSuccessResult messagePublishSystemTemplateResult =
         * rongCloud.message.publishSystemTemplate(publishSystemTemplateTemplateMessage)
         * ; System.out.println("publishSystemTemplate:  " +
         * messagePublishSystemTemplateResult.toString()); } catch (Exception e) { //
         * TODO: handle exception e.printStackTrace(); }finally { if(null != reader){
         * reader.close(); } }
         *
         * // 发送群组消息方法（以一个用户身份向群组发送消息，单条消息最大 128k.每秒钟最多发送 20 条消息，每次最多向 3 个群组发送，如：一次向 3
         * 个群组发送消息，示为 3 条消息。） String[] messagePublishGroupToGroupId =
         * {"groupId1","groupId2","groupId3"}; TxtMessage messagePublishGroupTxtMessage
         * = new TxtMessage("hello", "helloExtra"); CodeSuccessResult
         * messagePublishGroupResult = rongCloud.message.publishGroup("userId",
         * messagePublishGroupToGroupId, messagePublishGroupTxtMessage, "thisisapush",
         * "{\"pushData\":\"hello\"}", 1, 1, 0); System.out.println("publishGroup:  " +
         * messagePublishGroupResult.toString());
         *
         * // 发送讨论组消息方法（以一个用户身份向讨论组发送消息，单条消息最大 128k，每秒钟最多发送 20 条消息.） TxtMessage
         * messagePublishDiscussionTxtMessage = new TxtMessage("hello", "helloExtra");
         * CodeSuccessResult messagePublishDiscussionResult =
         * rongCloud.message.publishDiscussion("userId1", "discussionId1",
         * messagePublishDiscussionTxtMessage, "thisisapush",
         * "{\"pushData\":\"hello\"}", 1, 1, 0);
         * System.out.println("publishDiscussion:  " +
         * messagePublishDiscussionResult.toString());
         *
         * // 发送聊天室消息方法（一个用户向聊天室发送消息，单条消息最大 128k。每秒钟限 100 次。） String[]
         * messagePublishChatroomToChatroomId =
         * {"ChatroomId1","ChatroomId2","ChatroomId3"}; TxtMessage
         * messagePublishChatroomTxtMessage = new TxtMessage("hello", "helloExtra");
         * CodeSuccessResult messagePublishChatroomResult =
         * rongCloud.message.publishChatroom("userId1",
         * messagePublishChatroomToChatroomId, messagePublishChatroomTxtMessage);
         * System.out.println("publishChatroom:  " +
         * messagePublishChatroomResult.toString());
         *
         * // 发送广播消息方法（发送消息给一个应用下的所有注册用户，如用户未在线会对满足条件（绑定手机终端）的用户发送 Push 信息，单条消息最大
         * 128k，会话类型为 SYSTEM。每小时只能发送 1 次，每天最多发送 3 次。） TxtMessage
         * messageBroadcastTxtMessage = new TxtMessage("hello", "helloExtra");
         * CodeSuccessResult messageBroadcastResult =
         * rongCloud.message.broadcast("userId1", messageBroadcastTxtMessage,
         * "thisisapush", "{\"pushData\":\"hello\"}", "iOS");
         * System.out.println("broadcast:  " + messageBroadcastResult.toString());
         *
         * // 消息历史记录下载地址获取 方法消息历史记录下载地址获取方法。获取 APP
         * 内指定某天某小时内的所有会话消息记录的下载地址。（目前支持二人会话、讨论组、群组、聊天室、客服、系统通知消息历史记录下载）
         * HistoryMessageResult messageGetHistoryResult =
         * rongCloud.message.getHistory("2014010101");
         * System.out.println("getHistory:  " + messageGetHistoryResult.toString());
         *
         * // 消息历史记录删除方法（删除 APP
         * 内指定某天某小时内的所有会话消息记录。调用该接口返回成功后，date参数指定的某小时的消息记录文件将在随后的5-10分钟内被永久删除。）
         * CodeSuccessResult messageDeleteMessageResult =
         * rongCloud.message.deleteMessage("2014010101");
         * System.out.println("deleteMessage:  " +
         * messageDeleteMessageResult.toString());
         *
         *
         *
         * System.out.println("************************Wordfilter********************");
         * // 添加敏感词方法（设置敏感词后，App 中用户不会收到含有敏感词的消息内容，默认最多设置 50 个敏感词。） CodeSuccessResult
         * wordfilterAddResult = rongCloud.wordfilter.add("money");
         * System.out.println("add:  " + wordfilterAddResult.toString());
         *
         * // 查询敏感词列表方法 ListWordfilterResult wordfilterGetListResult =
         * rongCloud.wordfilter.getList(); System.out.println("getList:  " +
         * wordfilterGetListResult.toString());
         *
         * // 移除敏感词方法（从敏感词列表中，移除某一敏感词。） CodeSuccessResult wordfilterDeleteResult =
         * rongCloud.wordfilter.delete("money"); System.out.println("delete:  " +
         * wordfilterDeleteResult.toString());
         *
         *
         *
         * System.out.println(
         * "************************Sensitiveword********************"); //
         * 添加敏感词方法（设置敏感词后，App 中用户不会收到含有敏感词的消息内容，默认最多设置 50 个敏感词。） CodeSuccessResult
         * sensitivewordAddResult = rongCloud.sensitiveword.add("money", "****");
         * System.out.println("add:  " + sensitivewordAddResult.toString());
         *
         * // 查询敏感词列表方法 ListWordfilterResult sensitivewordGetListResult =
         * rongCloud.sensitiveword.getList(1); System.out.println("getList:  " +
         * sensitivewordGetListResult.toString());
         *
         * // 移除敏感词方法（从敏感词列表中，移除某一敏感词。） CodeSuccessResult sensitivewordDeleteResult =
         * rongCloud.sensitiveword.delete("money"); System.out.println("delete:  " +
         * sensitivewordDeleteResult.toString());
         *
         *
         *

         *
         *
         * // 添加禁言群成员方法（在 App
         * 中如果不想让某一用户在群中发言时，可将此用户在群组中禁言，被禁言用户可以接收查看群组中用户聊天信息，但不能发送消息。） CodeSuccessResult
         * groupAddGagUserResult = rongCloud.group.addGagUser("userId1", "groupId1",
         * "1"); System.out.println("addGagUser:  " + groupAddGagUserResult.toString());
         *
         * // 查询被禁言群成员方法 ListGagGroupUserResult groupLisGagUserResult =
         * rongCloud.group.lisGagUser("groupId1"); System.out.println("lisGagUser:  " +
         * groupLisGagUserResult.toString());
         *
         * // 移除禁言群成员方法 String[] groupRollBackGagUserUserId =
         * {"userId2","userid3","userId4"}; CodeSuccessResult groupRollBackGagUserResult
         * = rongCloud.group.rollBackGagUser(groupRollBackGagUserUserId, "groupId1");
         * System.out.println("rollBackGagUser:  " +
         * groupRollBackGagUserResult.toString());

         *
         *
         *

         *
         *
         * System.out.println("************************Push********************"); // 添加
         * Push 标签方法 try { reader = new InputStreamReader(new
         * FileInputStream(JSONFILE+"UserTag.json")); UserTag setUserPushTagUserTag =
         * (UserTag)GsonUtil.fromJson(reader, UserTag.class); CodeSuccessResult
         * pushSetUserPushTagResult =
         * rongCloud.push.setUserPushTag(setUserPushTagUserTag);
         * System.out.println("setUserPushTag:  " +
         * pushSetUserPushTagResult.toString()); } catch (Exception e) { // TODO: handle
         * exception e.printStackTrace(); }finally { if(null != reader){ reader.close();
         * } }
         *
         * // 广播消息方法（fromuserid 和 message为null即为不落地的push） try { reader = new
         * InputStreamReader(new FileInputStream(JSONFILE+"PushMessage.json"));
         * PushMessage broadcastPushPushMessage = (PushMessage)GsonUtil.fromJson(reader,
         * PushMessage.class); CodeSuccessResult pushBroadcastPushResult =
         * rongCloud.push.broadcastPush(broadcastPushPushMessage);
         * System.out.println("broadcastPush:  " + pushBroadcastPushResult.toString());
         * } catch (Exception e) { // TODO: handle exception e.printStackTrace();
         * }finally { if(null != reader){ reader.close(); } }
         *
         *
         *
         * System.out.println("************************SMS********************"); //
         * 获取图片验证码方法 SMSImageCodeResult sMSGetImageCodeResult =
         * rongCloud.sms.getImageCode("app-key"); System.out.println("getImageCode:  " +
         * sMSGetImageCodeResult.toString());
         *
         * // 发送短信验证码方法。 SMSSendCodeResult sMSSendCodeResult =
         * rongCloud.sms.sendCode("13500000000", "dsfdsfd", "86", "1408706337",
         * "1408706337"); System.out.println("sendCode:  " +
         * sMSSendCodeResult.toString());
         *
         * // 验证码验证方法 SMSVerifyCodeResult sMSVerifyCodeResult =
         * rongCloud.sms.verifyCode("2312312", "2312312");
         * System.out.println("verifyCode:  " + sMSVerifyCodeResult.toString());
         */

    }

    /**
     * 获取融云用户token
     *
     * @param @param  userId
     * @param @param  username
     * @param @param  headUrl
     * @param @return
     * @param @throws Exception    设定文件
     * @return String    返回类型
     * @throws
     * @Title: getToken
     * @Description: TODO(这里用一句话描述这个方法的作用)
     */
    public String getToken(String userId, String username, String headUrl) {
        String token = "";
        try {
            headUrl = headUrl == null ? "" : headUrl;
            TokenResult userGetTokenResult = rongCloud.user.getToken(userId, username, headUrl);
            token = userGetTokenResult.getCode() == 200 ? userGetTokenResult.getToken() : token;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return token;
    }


    /**
     * 刷新用户信息方法
     *
     * @param userId:用户      Id，最大长度 64 字节.是用户在 App 中的唯一标识码，必须保证在同一个 App 内不重复，重复的用户 Id 将被当作是同一用户。（必传）
     * @param name:用户名称，最大长度 128 字节。用来在 Push 推送时，显示用户的名称，刷新用户名称后 5 分钟内生效。（可选，提供即刷新，不提供忽略）
     * @param userUrl:用户头像   URI，最大长度 1024 字节。用来在 Push 推送时显示。（可选，提供即刷新，不提供忽略）
     * @return boolean 刷新成功返回true 刷新失败返回false
     * @Description: TODO(刷新用户信息方法)
     **/
    public boolean refreshUser(String userId, String name, String userUrl) {
        try {
            CodeSuccessResult codeSuccessResult = rongCloud.user.refresh(userId, name, userUrl);
            if (codeSuccessResult.getCode() == 200) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

    /**
     * 检查用户在线状态 方法
     *
     * @param userId:用户 Id，最大长度 64 字节.是用户在 App 中的唯一标识码，必须保证在同一个 App 内不重复，重复的用户 Id 将被当作是同一用户。（必传）
     * @return int 1:在线 0：不在线 2：请求失败
     * @Description: TODO(检查用户是否在线)
     **/
    public int checkUserOnLine(String userId) {
        try {
            CheckOnlineResult checkOnlineResult = rongCloud.user.checkOnline(userId);
            if (200 != checkOnlineResult.getCode()) {
                return Integer.valueOf(checkOnlineResult.getStatus());
            }
        } catch (Exception e) {
            e.printStackTrace();
            return 2;
        }
        return 2;
    }

    /**
     * 创建群组
     *
     * @param @param  userId 创建用户id
     * @param @param  groupId 群组id 需要在本地先创建群组
     * @param @param  groupName 群组名称
     * @param @throws Exception    设定文件
     * @return boolean 创建成功返回true 失败false
     * @Title: createGroup
     * @Description: TODO(创建群组)
     */
    public boolean createGroup(String userId, String groupId, String groupName) {
        try {
            String[] userIds = {userId};
            CodeSuccessResult codeSuccessResult = rongCloud.group.create(userIds, groupId, groupName);
            if (codeSuccessResult.getCode() != 200) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

    /**
     * 添加群组成员
     *
     * @param @param userIds 创建用户id集合
     * @param @param groupId 群组id
     * @param @param groupName 群组名称
     * @return boolean 添加群成员成功返回true 失败false
     * @Title: joinGroup
     * @Description: TODO(加入群组)
     */
    public boolean joinGroup(String[] userIds, String groupId, String groupName) {
        try {
            //首先调用融云接口，插入用户
            CodeSuccessResult codeSuccessResult = rongCloud.group.join(userIds, groupId, groupName);
            if (200 != codeSuccessResult.getCode()) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

    /**
     * 退出群组，或者群主删除群组成员
     *
     * @param @param userIds 创建用户id集合
     * @param @param groupId 群组id
     * @param @param groupName 群组名称
     * @return boolean 退出群或者删除群成员成功返回true 失败false
     * @Title: quitGroupUser
     * @Description: TODO(退出群组或者群主删除群成员)
     */
    public boolean quitGroupUser(String[] userIds, String groupId, String groupName) {
        try {
            //调用融云删除
            CodeSuccessResult codeSuccessResult = rongCloud.group.quit(userIds, groupId);
            if (codeSuccessResult.getCode() != 200) {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

    /**
     * 解散群组
     *
     * @param @param userId 操作用户id
     * @param @param groupId 群组id
     * @return boolean 解散成功返回true 失败false
     * @Title: dismissGroup
     * @Description: TODO(解散群组)
     */
    public boolean dismissGroup(String userId, String groupId) {
        try {
            CodeSuccessResult codeSuccessResult = rongCloud.group.dismiss(userId, groupId);
            if (200 != codeSuccessResult.getCode()) {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

    /**
     * 获取群组内成员
     *
     * @param @param userId 操作用户id
     * @param @param groupId 群组id
     * @return List<GroupUser> 获取群组内成员成功 返回群组成员，否则返回null
     * @Title: dismissGroup
     * @Description: TODO(获取群组成员)
     */
    public List<GroupUser> queryGroupUser(String groupId) {
        try {
            GroupUserQueryResult groupUserQueryResult = rongCloud.group.queryUser(groupId);
            if (200 != groupUserQueryResult.getCode()) {
                return groupUserQueryResult.getUsers();
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return null;
    }

    /**
     * 同步用户所属群组方法（当第一次连接融云服务器时，需要向融云服务器提交 userId 对应的用户当前所加入的所有群组，此接口主要为防止应用中用户群信息同融云已知的用户所属群信息不同步。）
     *
     * @param userId:被同步群信息的用户   Id。（必传）
     * @param groupInfo:该用户的群信息  ,如群 Id 已经存在，则不会刷新对应群组名称，如果想刷新群组名称请调用刷新群组信息方法。
     * @param GroupInfo:包含String id：群组Id；String name：群组名称。
     * @return boolean 同步成功返回true 失败返回false
     */
    public boolean syncGroup(String userId, List<GroupInfo> groupInfo) {
        try {
            CodeSuccessResult codeSuccessResult = rongCloud.group.sync(userId, groupInfo.toArray(new GroupInfo[groupInfo.size()]));
            if (200 != codeSuccessResult.getCode()) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

    /**
     * 获取某用户的黑名单列表方法（每秒钟限 100 次）
     *
     * @param userId:用户 Id。（必传）
     * @return String[] 返回黑名单人员集合
     */
    public String[] queryUserBlacklist(String userId) {
        try {
            QueryBlacklistUserResult queryBlacklistUserResult = rongCloud.user.queryBlacklist(userId);
            if (200 != queryBlacklistUserResult.getCode()) {
                return queryBlacklistUserResult.getUsers();
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return null;
    }

    /**
     * 添加用户到黑名单方法（每秒钟限 100 次）
     *
     * @param userId:用户Id。（必传）
     * @param blackUserId:被加到黑名单的用户Id。（必传）
     * @return boolean 添加黑名单成功：ture；失败：false
     */
    public boolean addUserBlacklist(String userId, String blackUserId) {
        try {
            CodeSuccessResult codeSuccessResult = rongCloud.user.addBlacklist(userId, blackUserId);
            if (200 != codeSuccessResult.getCode()) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

    /**
     * 从黑名单中移除用户方法（每秒钟限 100 次）
     *
     * @param userId:用户Id。（必传）
     * @param blackUserId:被移除的用户Id。（必传）
     * @return boolean 移除黑名单成功：ture；失败：false
     */
    public boolean removeUserBlacklist(String userId, String blackUserId) {
        try {
            CodeSuccessResult codeSuccessResult = rongCloud.user.removeBlacklist(userId, blackUserId);
            if (200 != codeSuccessResult.getCode()) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }
}